home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / AIncludes / MixedMode.a < prev    next >
Encoding:
Text File  |  1996-05-01  |  11.1 KB  |  329 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        MixedMode.a
  3. ;
  4. ;    Contains:    Mixed Mode Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Release:    Universal Interfaces 3.0d3 on Copland DR1
  8. ;
  9. ;    Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10. ;
  11. ;    Bugs?:        If you find a problem with this file, send the file and version
  12. ;                information (from above) and the problem description to:
  13. ;
  14. ;                    Internet:    apple.bugs@applelink.apple.com
  15. ;                    AppleLink:    APPLE.BUGS
  16. ;
  17. ;
  18.     IF &TYPE('__MIXEDMODE__') = 'UNDEFINED' THEN
  19. __MIXEDMODE__ SET 1
  20.  
  21.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  22.     include 'Types.a'
  23.     ENDIF
  24.     IF FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE THEN
  25. ;  Mixed Mode constants 
  26. ;  Current Routine Descriptor Version 
  27.  
  28. kRoutineDescriptorVersion        EQU        7
  29. ;  MixedModeMagic Magic Cookie/Trap number 
  30.  
  31. _MixedModeMagic                    EQU        $AAFE
  32. ;  Calling Conventions 
  33. ; typedef unsigned short                 CallingConventionType
  34.  
  35.  
  36. kPascalStackBased                EQU        0
  37. kCStackBased                    EQU        1
  38. kRegisterBased                    EQU        2
  39. kD0DispatchedPascalStackBased    EQU        8
  40. kD1DispatchedPascalStackBased    EQU        12
  41. kD0DispatchedCStackBased        EQU        9
  42. kStackDispatchedPascalStackBased EQU    14
  43. kThinkCStackBased                EQU        5
  44. ;  ISA Types 
  45. ; typedef SInt8                         ISAType
  46.  
  47.  
  48. kM68kISA                        EQU        0
  49. kPowerPCISA                        EQU        1
  50. ;  RTA Types 
  51. ; typedef SInt8                         RTAType
  52.  
  53.  
  54. kOld68kRTA                        EQU        $00
  55. kPowerPCRTA                        EQU        $00
  56. kCFM68kRTA                        EQU        $10
  57. ;  Constants for specifing 68k registers 
  58.  
  59. kRegisterD0                        EQU        0
  60. kRegisterD1                        EQU        1
  61. kRegisterD2                        EQU        2
  62. kRegisterD3                        EQU        3
  63. kRegisterD4                        EQU        8
  64. kRegisterD5                        EQU        9
  65. kRegisterD6                        EQU        10
  66. kRegisterD7                        EQU        11
  67. kRegisterA0                        EQU        4
  68. kRegisterA1                        EQU        5
  69. kRegisterA2                        EQU        6
  70. kRegisterA3                        EQU        7
  71. kRegisterA4                        EQU        12
  72. kRegisterA5                        EQU        13
  73. kRegisterA6                        EQU        14                    ; A7 is the same as the PowerPC SP 
  74. kCCRegisterCBit                    EQU        16
  75. kCCRegisterVBit                    EQU        17
  76. kCCRegisterZBit                    EQU        18
  77. kCCRegisterNBit                    EQU        19
  78. kCCRegisterXBit                    EQU        20
  79. ; typedef unsigned short                 registerSelectorType
  80.  
  81. ;  SizeCodes we use everywhere 
  82.  
  83. kNoByteCode                        EQU        0
  84. kOneByteCode                    EQU        1
  85. kTwoByteCode                    EQU        2
  86. kFourByteCode                    EQU        3
  87. ;  Mixed Mode Routine Records 
  88. ; typedef unsigned long                 ProcInfoType
  89.  
  90. ;  Routine Flag Bits 
  91. ; typedef unsigned short                 RoutineFlagsType
  92.  
  93.  
  94. kProcDescriptorIsAbsolute        EQU        $00
  95. kProcDescriptorIsRelative        EQU        $01
  96.  
  97. kFragmentIsPrepared                EQU        $00
  98. kFragmentNeedsPreparing            EQU        $02
  99.  
  100. kUseCurrentISA                    EQU        $00
  101. kUseNativeISA                    EQU        $04
  102.  
  103. kPassSelector                    EQU        $00
  104. kDontPassSelector                EQU        $08
  105.  
  106. kRoutineIsNotDispatchedDefaultRoutine EQU $00
  107. kRoutineIsDispatchedDefaultRoutine EQU    $10
  108.     ENDIF
  109.     IF FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE THEN
  110.  
  111. kProcDescriptorIsProcPtr        EQU        $00
  112. kProcDescriptorIsIndex            EQU        $20
  113. RoutineRecord            RECORD 0
  114. procInfo                 ds.l    1                ; offset: $0 (0)        ;  calling conventions 
  115. reserved1                 ds.b    1                ; offset: $4 (4)        ;  Must be 0 
  116. ISA                         ds.b    1                ; offset: $5 (5)        ;  Instruction Set Architecture 
  117. routineFlags             ds.w    1                ; offset: $6 (6)        ;  Flags for each routine 
  118. procDescriptor             ds.l    1                ; offset: $8 (8)        ;  Where is the thing we’re calling? 
  119. reserved2                 ds.l    1                ; offset: $C (12)        ;  Must be 0 
  120. selector                 ds.l    1                ; offset: $10 (16)        ;  For dispatched routines, the selector 
  121. sizeof                     EQU *                    ; size:   $14 (20)
  122.                         ENDR
  123. ; typedef struct RoutineRecord *        RoutineRecordPtr
  124.  
  125. ; typedef RoutineRecordPtr *            RoutineRecordHandle
  126.  
  127. ;  Mixed Mode Routine Descriptors 
  128. ;  Definitions of the Routine Descriptor Flag Bits 
  129. ; typedef UInt8                         RDFlagsType
  130.  
  131.  
  132. kSelectorsAreNotIndexable        EQU        $00
  133. kSelectorsAreIndexable            EQU        $01
  134. ;  Routine Descriptor Structure 
  135. RoutineDescriptor        RECORD 0
  136. goMixedModeTrap             ds.w    1                ; offset: $0 (0)        ;  Our A-Trap 
  137. version                     ds.b    1                ; offset: $2 (2)        ;  Current Routine Descriptor version 
  138. routineDescriptorFlags     ds.b    1                ; offset: $3 (3)        ;  Routine Descriptor Flags 
  139. reserved1                 ds.l    1                ; offset: $4 (4)        ;  Unused, must be zero 
  140. reserved2                 ds.b    1                ; offset: $8 (8)        ;  Unused, must be zero 
  141. selectorInfo             ds.b    1                ; offset: $9 (9)        ;  If a dispatched routine, calling convention, else 0 
  142. routineCount             ds.w    1                ; offset: $A (10)        ;  Number of routines in this RD 
  143. routineRecords             ds        RoutineRecord    ; offset: $C (12) <-- really an array of length one ;  The individual routines 
  144. sizeof                     EQU *                    ; size:   $20 (32)
  145.                         ENDR
  146. ; typedef struct RoutineDescriptor *    RoutineDescriptorPtr
  147.  
  148. ; typedef RoutineDescriptorPtr *        RoutineDescriptorHandle
  149.  
  150.     ENDIF
  151.     IF FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE THEN
  152. ;  Mixed Mode ProcInfos 
  153.  
  154.                                                             ; Calling Convention Offsets 
  155. kCallingConventionWidth            EQU        4
  156. kCallingConventionPhase            EQU        0
  157. kCallingConventionMask            EQU        $0F                    ; Result Offsets 
  158. kResultSizeWidth                EQU        2
  159. kResultSizePhase                EQU        4
  160. kResultSizeMask                    EQU        $30                    ; Parameter offsets & widths 
  161. kStackParameterWidth            EQU        2
  162. kStackParameterPhase            EQU        6
  163. kStackParameterMask                EQU        $FFFFFFC0            ; Register Result Location offsets & widths 
  164. kRegisterResultLocationWidth    EQU        5
  165. kRegisterResultLocationPhase    EQU        6                    ; Register Parameter offsets & widths 
  166. kRegisterParameterWidth            EQU        5
  167. kRegisterParameterPhase            EQU        11
  168. kRegisterParameterMask            EQU        $7FFFF800
  169. kRegisterParameterSizePhase        EQU        0
  170. kRegisterParameterSizeWidth        EQU        2
  171. kRegisterParameterWhichPhase    EQU        2
  172. kRegisterParameterWhichWidth    EQU        3                    ; Dispatched Stack Routine Selector offsets & widths 
  173. kDispatchedSelectorSizeWidth    EQU        2
  174. kDispatchedSelectorSizePhase    EQU        6                    ; Dispatched Stack Routine Parameter offsets 
  175. kDispatchedParameterPhase        EQU        8                    ; Special Case offsets & widths 
  176. kSpecialCaseSelectorWidth        EQU        6
  177. kSpecialCaseSelectorPhase        EQU        4
  178. kSpecialCaseSelectorMask        EQU        $03F0
  179.     ENDIF
  180.     IF FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE THEN
  181.  
  182. kSpecialCase                    EQU        $000F                ; (CallingConventionType) 
  183.  
  184.                                                             ; all of the special cases enumerated.  The selector field is 6 bits wide 
  185. kSpecialCaseHighHook            EQU        0
  186. kSpecialCaseCaretHook            EQU        0                    ; same as kSpecialCaseHighHook 
  187. kSpecialCaseEOLHook                EQU        1
  188. kSpecialCaseWidthHook            EQU        2
  189. kSpecialCaseTextWidthHook        EQU        2                    ; same as kSpecialCaseWidthHook 
  190. kSpecialCaseNWidthHook            EQU        3
  191. kSpecialCaseDrawHook            EQU        4
  192. kSpecialCaseHitTestHook            EQU        5
  193. kSpecialCaseTEFindWord            EQU        6
  194. kSpecialCaseProtocolHandler        EQU        7
  195. kSpecialCaseSocketListener        EQU        8
  196. kSpecialCaseTERecalc            EQU        9
  197. kSpecialCaseTEDoText            EQU        10
  198. kSpecialCaseGNEFilterProc        EQU        11
  199. kSpecialCaseMBarHook            EQU        12
  200. ;
  201. ;    NOTES ON USING ROUTINE DESCRIPTOR FUNCTIONS
  202. ;    
  203. ;    When calling these routine from classic 68k code there are two possible intentions.
  204. ;
  205. ;    The first is source compatibility with code ported to CFM (either PowerPC or 68k CFM). When
  206. ;    the code is compiled for CFM the functions create routine descriptors that can be used by
  207. ;    the mixed mode manager operating on that machine. When the code is compiled for classic 68k
  208. ;    these functions do nothing so that the code will run on Macintoshes that do not have a
  209. ;    mixed mode manager. The dual nature of these functions is achieved by turning the CFM calls
  210. ;    into "no-op" macros for classic 68k: You can put "NewRoutineDescriptor" in your source,
  211. ;    compile it for any runtime or instruction set architecture, and it will run correctly on the
  212. ;    intended runtime/instruction platform. All without source changes and/or conditional source.
  213. ;    
  214. ;    The other intention is for code that "knows" that it is executing as classic 68k runtime
  215. ;    and is specifically trying to call code of another architecture using mixed mode. Since the
  216. ;    routines were designed with classic <-> CFM source compatibility in mind this second case
  217. ;    is treated special. For classic 68k code to create routines descriptors for use by mixed mode
  218. ;    it must call the "Trap" versions of the routines (NewRoutineDescriptorTrap). These versions
  219. ;    are only available to classic 68k callers: rigging the interfaces to allow calling them
  220. ;    from CFM code will result in runtime failure because no shared library implements or exports
  221. ;    the functions.
  222. ;    
  223. ;
  224. ;    This almost appears seamless until you consider "fat" routine descriptors and the advent of
  225. ;    CFM-68K. What does "fat" mean? CFM-68K is not emulated on PowerPC and PowerPC is not emulated
  226. ;    on CFM-68K. It makes no sense to create a routine descriptor having both a CFM-68K routine
  227. ;    and a PowerPC native routine pointer. Therefore "fat" is defined to be a mix of classic and
  228. ;    CFM for the hardware's native instruction set: on PowerPC fat is classic and PowerPC native,
  229. ;    on a 68k machine with CFM-68K installed fat is classic and CFM-68K.
  230. ;    
  231. ;    By definition fat routine descriptors are only constructed by code that is aware of the 
  232. ;    architecture it is executing as and that another architecture exists. Source compatibility
  233. ;    between code intented as pure classic and pure CFM is not an issue and so NewFatRoutineDescriptor
  234. ;    is not available when building pure classic code.
  235. ;    
  236. ;    NewFatRoutineDescriptorTrap is available to classic code on both PowerPC and CFM-68K. The
  237. ;    classic code can use the code fragment manager routine "FindSymbol" to obtain the address of 
  238. ;    a routine in a shared library and then construct a routine descriptor with both the CFM routine 
  239. ;    and classic    routine.
  240. ;
  241.     IF GENERATINGCFM THEN
  242. ;
  243. ; pascal UniversalProcPtr NewRoutineDescriptor(ProcPtr theProc, ProcInfoType theProcInfo, ISAType theISA)
  244. ;
  245.     IF GENERATINGCFM THEN
  246.         IMPORT_CFM_FUNCTION NewRoutineDescriptor
  247.     ENDIF
  248.  
  249. ;
  250. ; pascal void DisposeRoutineDescriptor(UniversalProcPtr theProcPtr)
  251. ;
  252.     IF GENERATINGCFM THEN
  253.         IMPORT_CFM_FUNCTION DisposeRoutineDescriptor
  254.     ENDIF
  255.  
  256. ;
  257. ; pascal UniversalProcPtr NewFatRoutineDescriptor(ProcPtr theM68kProc, ProcPtr thePowerPCProc, ProcInfoType theProcInfo)
  258. ;
  259.     IF GENERATINGCFM THEN
  260.         IMPORT_CFM_FUNCTION NewFatRoutineDescriptor
  261.     ENDIF
  262.  
  263.     ELSE
  264. ;
  265. ; pascal UniversalProcPtr NewRoutineDescriptorTrap(ProcPtr theProc, ProcInfoType theProcInfo, ISAType theISA)
  266. ;
  267.     IF ¬ GENERATINGCFM THEN
  268.         Macro
  269.         _NewRoutineDescriptorTrap
  270.             moveq               #0,D0
  271.             dc.w                $AA59
  272.         EndM
  273.     ELSE
  274.         IMPORT_CFM_FUNCTION NewRoutineDescriptorTrap
  275.     ENDIF
  276.  
  277. ;
  278. ; pascal void DisposeRoutineDescriptorTrap(UniversalProcPtr theProcPtr)
  279. ;
  280.     IF ¬ GENERATINGCFM THEN
  281.         Macro
  282.         _DisposeRoutineDescriptorTrap
  283.             moveq               #1,D0
  284.             dc.w                $AA59
  285.         EndM
  286.     ELSE
  287.         IMPORT_CFM_FUNCTION DisposeRoutineDescriptorTrap
  288.     ENDIF
  289.  
  290. ;
  291. ; pascal UniversalProcPtr NewFatRoutineDescriptorTrap(ProcPtr theM68kProc, ProcPtr thePowerPCProc, ProcInfoType theProcInfo)
  292. ;
  293.     IF ¬ GENERATINGCFM THEN
  294.         Macro
  295.         _NewFatRoutineDescriptorTrap
  296.             moveq               #2,D0
  297.             dc.w                $AA59
  298.         EndM
  299.     ELSE
  300.         IMPORT_CFM_FUNCTION NewFatRoutineDescriptorTrap
  301.     ENDIF
  302.  
  303. ;  Note that the call to NewFatRoutineDescriptor is undefined when GENERATINGCFM is false. 
  304.     ENDIF
  305.     IF GENERATINGCFM THEN
  306. ;
  307. ; CallUniversalProc is only implemented in shared libraries on 68k and PowerPC, it is now
  308. ; conditionalize with GENERATINGCFM.  This will catch accidental calls from classic 68K code
  309. ; that previously only showed up as linker errors.
  310. ;
  311. ;
  312. ; extern long CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...)
  313. ;
  314.     IF GENERATINGCFM THEN
  315.         IMPORT_CFM_FUNCTION CallUniversalProc
  316.     ENDIF
  317.  
  318. ;
  319. ; extern long CallOSTrapUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...)
  320. ;
  321.     IF GENERATINGCFM THEN
  322.         IMPORT_CFM_FUNCTION CallOSTrapUniversalProc
  323.     ENDIF
  324.  
  325.     ENDIF
  326.     ENDIF
  327.     ENDIF ; __MIXEDMODE__ 
  328.  
  329.